home *** CD-ROM | disk | FTP | other *** search
/ BBS in a Box 12 / BBS in a box XII-2.iso / Files II / Prog / D-G / Extension Shell 1.3.sit / Extension Shell 1.3 ƒ / Extension Shell 1.3 (Source) / UninstallCode.c / UninstallCode.c
Encoding:
Text File  |  1994-04-06  |  7.6 KB  |  331 lines  |  [TEXT/R*ch]
  1. /*    NAME:
  2.         UninstallCode.c
  3.  
  4.     WRITTEN BY:
  5.         Dair Grant
  6.                 
  7.     DESCRIPTION:
  8.         Routines for uninstalling the various code resources Extension Shell supports.
  9.  
  10.     NOTES:
  11.         •    Not everything that can be installed can be uninstalled.
  12.  
  13.     ___________________________________________________________________________
  14.  
  15.     VERSION HISTORY:
  16.         (Jan 1994, dg)
  17.             •    Added low-memory filter support.
  18.  
  19.         (Jan 1994, dg)
  20.             •    First publicly distributed version.
  21.  
  22.         (Mar 1994, dg)
  23.             •    Added support for code blocks.
  24.             
  25.             
  26.     ___________________________________________________________________________
  27. */
  28. //=============================================================================
  29. //        Include files                                                                     
  30. //-----------------------------------------------------------------------------
  31. #include <GestaltEqu.h>
  32. #include "ParamBlock.h"
  33. #include "UninstallCode.h"
  34. #include "ExtensionShell.h"
  35. #include "AddrsTable.h"
  36.  
  37.  
  38.  
  39.  
  40.  
  41. //=============================================================================
  42. //        Private function prototypes                                                                     
  43. //-----------------------------------------------------------------------------
  44. void    UninstallTrapPatch(short i);
  45. void    UninstallGestaltSelector(short i);
  46. void    UninstallShutdownTask(short i);
  47. void    UninstallVBLTask(short i);
  48. void    UninstallLowMemFilter(short i);
  49. void    UninstallCodeBlock(short i);
  50. void    UninstallTimeManagerTask(short i);
  51.  
  52.  
  53.  
  54.  
  55.  
  56. //=============================================================================
  57. //        Global variables                                                                 
  58. //-----------------------------------------------------------------------------
  59. extern ESParamBlock        gTheParamBlock;
  60. extern AddressTable        *gTheAddressTable;
  61.  
  62.  
  63.  
  64.  
  65.  
  66.  
  67.  
  68.  
  69.  
  70.  
  71. //=============================================================================
  72. //        UninstallCode : Uninstall a code resource depending on its type.                                                                 
  73. //-----------------------------------------------------------------------------
  74. //        Note :    Not all types can be removed successfully. Right now, we still
  75. //                don't know of a clean way to remove a Gestalt Selector.
  76. //-----------------------------------------------------------------------------
  77. void UninstallCode(short i)
  78. {
  79.  
  80.  
  81.  
  82.  
  83.     // Case out on the type of the code, and call the uninstall routine
  84.     switch(gTheParamBlock.theCodeResources[i].codeType) {
  85.         case kTrapPatchType:
  86.              UninstallTrapPatch(i);
  87.              break;
  88.              
  89.         case kGestaltSelectorType:
  90.              UninstallGestaltSelector(i);
  91.              break;
  92.              
  93.         case kShutdownTaskType:
  94.              UninstallShutdownTask(i);
  95.              break;
  96.              
  97.         case kVBLTaskType:
  98.              UninstallVBLTask(i);
  99.              break;
  100.         
  101.         case kLowMemFilterType:
  102.              UninstallLowMemFilter(i);
  103.              break;
  104.         
  105.         case kCodeBlockType:
  106.              UninstallCodeBlock(i);
  107.              break;
  108.         
  109.         case kTimeManagerTaskType:
  110.              UninstallTimeManagerTask(i);
  111.              break;
  112.              
  113.         default:
  114.              ;
  115.     }
  116. } 
  117.  
  118.  
  119.  
  120.  
  121.  
  122.  
  123.  
  124.  
  125.  
  126.  
  127. //=============================================================================
  128. //        UninstallTrapPatch : Uninstall a trap patch.                                                         
  129. //-----------------------------------------------------------------------------
  130. //        Note :    We check the value currently held in the dispatch table. If
  131. //                it's still the same as our address, then it's safe to remove
  132. //                our routine. We do this just by replacing the dispatch table
  133. //                entry with the old value we originally replaced.
  134. //-----------------------------------------------------------------------------
  135. void UninstallTrapPatch(short i)
  136. {    int            trapNum;
  137.     ProcPtr        currentCode;
  138.     ProcPtr        oldCodeAddress;
  139.     TrapType    tType;
  140.     ProcPtr        currentDispatch;
  141.     Handle        theHnd;
  142.     
  143.  
  144.     
  145.  
  146.      // Copy the relevent details into local variables for speed
  147.      trapNum            = gTheParamBlock.theCodeResources[i].theCodeThing.theTrapPatch.trapNum;
  148.      currentCode        = (ProcPtr) gTheParamBlock.theCodeResources[i].theAddress;
  149.      oldCodeAddress    = gTheAddressTable->theTable[i];
  150.      
  151.      
  152.      
  153.      // Get the type of the trap
  154.     tType = GetTrapType(trapNum);
  155.     
  156.     
  157.     
  158.     // Compare the value in the dispatch table with our own code. If they match,
  159.     // then it's safe to remove the patch. Otherwise we're stuck.
  160.     currentDispatch = (ProcPtr) StripAddress((Ptr) NGetTrapAddress(trapNum, tType));
  161.     if (currentDispatch == currentCode)
  162.         {
  163.         // Overwrite the dispatch table entry with the old address.
  164.         NSetTrapAddress((long) StripAddress(oldCodeAddress), trapNum, tType);
  165.    
  166.    
  167.         
  168.         // Recover a handle to our code, and throw it away
  169.         theHnd = RecoverHandle(currentCode);
  170.         HUnlock(theHnd);
  171.         DisposHandle(theHnd);
  172.         }
  173. }
  174.  
  175.  
  176.  
  177.  
  178.  
  179.  
  180.  
  181.  
  182.  
  183.  
  184. //=============================================================================
  185. //        UninstallGestaltSelector : Uninstall a Gestalt Selector.                                                         
  186. //-----------------------------------------------------------------------------
  187. //        Note :    I don't know a way of removing a Gestalt Selector at present.
  188. //                We just have to leave them floating around for now. :-(
  189. //-----------------------------------------------------------------------------
  190. void UninstallGestaltSelector(short i)
  191. {
  192. }
  193.  
  194.  
  195.  
  196.  
  197.  
  198.  
  199.  
  200.  
  201.  
  202.  
  203. //=============================================================================
  204. //        UninstallShutdownTask : Uninstall a Shutdown Task.                                                         
  205. //-----------------------------------------------------------------------------
  206. void UninstallShutdownTask(short i)
  207. {
  208.  
  209.  
  210.     // Remove the shutdown task
  211.     ShutDwnRemove((ShutDwnProcPtr) gTheParamBlock.theCodeResources[i].theAddress);
  212. }
  213.  
  214.  
  215.  
  216.  
  217.  
  218.  
  219.  
  220.  
  221.  
  222.  
  223. //=============================================================================
  224. //        UninstallVBLTask : Uninstall a VBL task.                                                         
  225. //-----------------------------------------------------------------------------
  226. void UninstallVBLTask(short i)
  227. {
  228.  
  229.  
  230.     // Remove the VBL task
  231.     VRemove((QElemPtr) gTheParamBlock.theCodeResources[i].theAddress);
  232. }
  233.  
  234.  
  235.  
  236.  
  237.  
  238.  
  239.  
  240.  
  241.  
  242.  
  243. //=============================================================================
  244. //        UninstallLowMemFilter : Remove a low-memory filter.                                                         
  245. //-----------------------------------------------------------------------------
  246. void UninstallLowMemFilter(short i)
  247. {    Handle        theHnd;
  248.     ProcPtr        theEntryPoint, currentHead, oldHead, ourCode;
  249.  
  250.  
  251.     
  252.     
  253.     // Get the address of the filter chain
  254.     theEntryPoint = (ProcPtr) gTheParamBlock.theCodeResources[i].theCodeThing.theLowMemFilter.theEntryPoint;
  255.     
  256.     
  257.     
  258.     // Find out where everything else is
  259.     currentHead    = (ProcPtr) *((ProcPtr *) theEntryPoint);
  260.     oldHead        = gTheAddressTable->theTable[i];
  261.     ourCode        = gTheParamBlock.theCodeResources[i].theAddress;
  262.     
  263.     
  264.     
  265.     // Compare the value at the head of the chain with our own code. If
  266.     // they match, then we can remove our filter. Otherwise we're stuck.
  267.     if (currentHead == ourCode)
  268.         {
  269.         // Overwrite the entry at the head of the chain with the original
  270.         *((ProcPtr *) theEntryPoint) = oldHead;
  271.         
  272.         
  273.         
  274.         // Recover a handle to our code, and throw it away
  275.         theHnd = RecoverHandle(ourCode);
  276.         HUnlock(theHnd);
  277.         DisposHandle(theHnd);
  278.         }
  279. }
  280.  
  281.  
  282.  
  283.  
  284.  
  285.  
  286.  
  287.  
  288.  
  289.  
  290. //=============================================================================
  291. //        UninstallCodeBlock : Remove a block of code.                                                         
  292. //-----------------------------------------------------------------------------
  293. void UninstallCodeBlock(short i)
  294. {    ProcPtr        theCode;
  295.     Handle        theHnd;
  296.     
  297.  
  298.     
  299.  
  300.      // Get the pointer to the code block
  301.      theCode = (ProcPtr) gTheParamBlock.theCodeResources[i].theAddress;
  302.  
  303.      
  304.      
  305.      // Recover a handle and dispose of it
  306.      theHnd = RecoverHandle(theCode);
  307.     HUnlock(theHnd);
  308.     DisposHandle(theHnd);
  309. }
  310.  
  311.  
  312.  
  313.  
  314.  
  315.  
  316.  
  317.  
  318.  
  319.  
  320. //=============================================================================
  321. //        UninstallTimeManagerTask : Remove a Time Manager task.                                                         
  322. //-----------------------------------------------------------------------------
  323. void UninstallTimeManagerTask(short i)
  324. {
  325.  
  326.  
  327.  
  328.     // Remove the Time Manager task
  329.     RmvTime((QElemPtr) gTheParamBlock.theCodeResources[i].theAddress);
  330. }
  331.